import Request from '@/utils/request';
import Mustache from 'mustache';

const request = new Request({
  baseURL: 'http://localhost:8080',
  timeout: 10000,
});

// 基础URL
const BASE_URL = 'http://localhost:8080';

/**
 * 模板服务 - 用于从后端获取模板内容
 */
const templateService = {
  /**
   * 获取模板内容
   * @param {string} templatePath - 模板相对路径，如 'header.htm'
   * @returns {Promise<string>} - 模板内容
   */
  async getTemplate(templatePath) {
    if (!templatePath) {
      console.error('模板路径为空');
      return '';
    }
    
    try {
      // 构建完整的模板路径
      const fullPath = `/template/1/default/${templatePath}`;
      const completeUrl = `${BASE_URL}${fullPath}`;
      console.log('获取模板，完整URL:', completeUrl);
      
      // 使用uni.request替代fetch API
      return new Promise((resolve, reject) => {
        uni.request({
          url: completeUrl,
          method: 'GET',
          success: (res) => {
            if (res.statusCode === 200) {
              const templateContent = res.data;
              console.log(`模板【${templatePath}】获取成功，内容长度: ${templateContent.length}`);
              console.log('模板内容:', templateContent);
              resolve(templateContent);
            } else {
              reject(new Error(`模板获取失败: ${res.statusCode}`));
            }
          },
          fail: (err) => {
            console.error(`获取模板【${templatePath}】失败:`, err);
            reject(err);
          }
        });
      });
    } catch (error) {
      console.error(`获取模板【${templatePath}】失败:`, error);
      return '';
    }
  },

  /**
   * 根据分类数据获取列表模板
   * @param {Object} category - 分类数据对象
   * @returns {Promise<string>} - 模板内容
   */
  async getCategoryListTemplate(category) {
    if (!category) return '';
    
    const templateName = category.categoryListUrl;
    console.log(`分类【${category.categoryTitle || category.typetitle}】的列表模板名称:`, templateName);
    
    if (!templateName) {
      console.warn(`分类【${category.categoryTitle || category.typetitle}】没有设置列表模板`);
      return '';
    }
    
    return this.getTemplate(templateName);
  },

  /**
   * 根据分类数据获取详情模板
   * @param {Object} category - 分类数据对象
   * @returns {Promise<string>} - 模板内容
   */
  async getCategoryDetailTemplate(category) {
    if (!category) return '';
    
    const templateName = category.categoryUrl;
    console.log(`分类【${category.categoryTitle || category.typetitle}】的详情模板名称:`, templateName);
    
    if (!templateName) {
      console.warn(`分类【${category.categoryTitle || category.typetitle}】没有设置详情模板`);
      return '';
    }
    
    return this.getTemplate(templateName);
  },

  /**
   * 解析模板并替换变量
   * @param {string} template - 模板内容
   * @param {Object} data - 要替换的数据
   * @returns {string} - 解析后的内容
   */
  parseTemplate(template, data) {
    if (!template) return '';
    // 使用 mustache 进行渲染
    try {
      return Mustache.render(template, data);
    } catch (e) {
      console.error('[模板渲染] mustache 渲染异常:', e);
      return '';
    }
  },
  
  /**
   * 根据路径获取对象中的值
   * @private
   */
  _getValueByPath(obj, path) {
    const parts = path.split('.');
    let result = obj;
    
    for (const part of parts) {
      if (result === undefined || result === null) {
        return undefined;
      }
      result = result[part];
    }
    
    return result;
  },

  /**
   * 获取图片URL，确保使用相对路径或可访问的URL
   * @private
   */
  _getSecureImageUrl(url) {
    if (!url) return '';
    
    // 如果是相对路径，直接使用相对路径
    if (!url.startsWith('http://') && !url.startsWith('https://')) {
      return url; // 使用相对路径，小程序会自动处理
    }
    
    // 如果是HTTP协议，移除协议部分使用相对路径
    if (url.startsWith('http://localhost:8080')) {
      return url.replace('http://localhost:8080', '');
    }
    
    // 如果是HTTPS协议但指向localhost，移除协议部分使用相对路径
    if (url.startsWith('https://localhost:8080')) {
      return url.replace('https://localhost:8080', '');
    }
    
    // 其他情况保持原样
    return url;
  },

  /**
   * 格式化日期
   * @private
   */
  _formatDate(dateStr, format) {
    if (!dateStr) return '';
    
    try {
      const date = new Date(dateStr);
      
      // 替换年月日
      let result = format
        .replace(/yyyy/g, date.getFullYear())
        .replace(/MM/g, String(date.getMonth() + 1).padStart(2, '0'))
        .replace(/dd/g, String(date.getDate()).padStart(2, '0'))
        .replace(/HH/g, String(date.getHours()).padStart(2, '0'))
        .replace(/mm/g, String(date.getMinutes()).padStart(2, '0'))
        .replace(/ss/g, String(date.getSeconds()).padStart(2, '0'));
      
      return result;
    } catch (error) {
      return dateStr;
    }
  },
  
  /**
   * 格式化标签
   * @private
   */
  _formatTags(tags) {
    if (!tags) return '';
    
    try {
      const tagArr = typeof tags === 'string' ? tags.split(',') : (Array.isArray(tags) ? tags : []);
      return tagArr.map(tag => `<span class="tag">${tag}</span>`).join('');
    } catch (error) {
      return tags;
    }
  },
  
  /**
   * 格式化图片列表
   * @private
   */
  _formatImages(images) {
    if (!images) return '';
    
    try {
      let imageList = images;
      if (typeof images === 'string') {
        const cleanStr = images.replace(/\\/g, '');
        imageList = JSON.parse(cleanStr);
      }
      
      if (Array.isArray(imageList) && imageList.length > 0) {
        return `<div class="swiper-container">
          <div class="swiper-wrapper">
            ${imageList.map((img, index) => {
              const url = typeof img === 'object' ? img.url : img;
              const imgUrl = this._getSecureImageUrl(url);
              return `<div class="swiper-slide"><img src="${imgUrl}" alt="图片${index+1}" /></div>`;
            }).join('')}
          </div>
          <div class="swiper-pagination"></div>
        </div>`;
      }
      
      return '';
    } catch (error) {
      return '';
    }
  },
  
  /**
   * 渲染分页
   * @private
   */
  _renderPagination(data) {
    const { page = 1, totalPages = 1 } = data;
    
    if (totalPages <= 1) return '';
    
    let html = '<div class="pagination">';
    
    // 上一页
    if (page > 1) {
      html += `<a href="javascript:;" class="page-prev" data-page="${page-1}">上一页</a>`;
    } else {
      html += `<span class="page-prev disabled">上一页</span>`;
    }
    
    // 页码
    const start = Math.max(1, page - 2);
    const end = Math.min(totalPages, page + 2);
    
    if (start > 1) {
      html += `<a href="javascript:;" class="page-num" data-page="1">1</a>`;
      if (start > 2) {
        html += `<span class="page-ellipsis">...</span>`;
      }
    }
    
    for (let i = start; i <= end; i++) {
      if (i === page) {
        html += `<span class="page-num current">${i}</span>`;
      } else {
        html += `<a href="javascript:;" class="page-num" data-page="${i}">${i}</a>`;
      }
    }
    
    if (end < totalPages) {
      if (end < totalPages - 1) {
        html += `<span class="page-ellipsis">...</span>`;
      }
      html += `<a href="javascript:;" class="page-num" data-page="${totalPages}">${totalPages}</a>`;
    }
    
    // 下一页
    if (page < totalPages) {
      html += `<a href="javascript:;" class="page-next" data-page="${page+1}">下一页</a>`;
    } else {
      html += `<span class="page-next disabled">下一页</span>`;
    }
    
    html += '</div>';
    
    return html;
  },
  
  /**
   * 将flag格式化为HTML标签
   * @private
   */
  _formatFlagToHtml(flags) {
    if (!flags) return '';
    
    const flagArray = flags.split(',');
    let html = '';
    
    flagArray.forEach(flag => {
      let color = '#888';
      if (flag.toLowerCase().includes('头条')) color = '#ff5a5f';
      if (flag.toLowerCase().includes('推荐')) color = '#ff9800';
      if (flag.toLowerCase().includes('幻灯')) color = '#2196f3';
      
      html += `<span class="flag-tag" style="background-color:${color}">${flag}</span>`;
    });
    
    return html;
  },
  
  /**
   * 将flag格式化为CSS类名
   * @private
   */
  _formatFlagToClass(flags) {
    if (!flags) return '';
    
    const flagArray = flags.split(',');
    return flagArray.map(flag => `flag-${flag}`).join(' ');
  }
};

export default templateService; 